The commands in this section perform general-purpose algebraic manipulations. They work on the whole formula at the top of the stack (unless, of course, you have made a selection in that formula).
Many algebra commands prompt for a variable name or formula. If you answer the prompt with a blank line, the variable or formula is taken from top-of-stack, and the normal argument for the command is taken from the second-to-top stack level.
The a v
(calc-alg-evaluate) command performs the normal
default simplifications on a formula; for example,
‘a - -b’ is
changed to ‘a +
b’. These simplifications are normally done
automatically on all Calc results, so this command is useful only
if you have turned default simplifications off with an m
O command. See Simplification
Modes.
It is often more convenient to type =, which is like a v but which also substitutes stored values for variables in the formula. Use a v if you want the variables to ignore their stored values.
If you give a numeric prefix argument of 2 to a v, it simplifies as if in Algebraic Simplification mode. This is equivalent to typing a s; see Simplifying Formulas. If you give a numeric prefix of 3 or more, it uses Extended Simplification mode (a e).
If you give a negative prefix argument -1, -2, or -3, it simplifies in the corresponding mode but only works on the top-level function call of the formula. For example, ‘(2 + 3) * (2 + 3)’ will simplify to ‘(2 + 3)^2’, without simplifying the sub-formulas ‘2 + 3’. As another example, typing V R + to sum the vector ‘[1, 2, 3, 4]’ produces the formula ‘reduce(add, [1, 2, 3, 4])’ in No-Simplify mode. Using a v will evaluate this all the way to 10; using C-u - a v will evaluate it only to ‘1 + 2 + 3 + 4’. (See Reducing and Mapping.)
The =
command corresponds to the evalv function, and the
related N command, which is like = but
temporarily disables Symbolic mode (m s) during the
evaluation, corresponds to the evalvn function.
(These commands interpret their prefix arguments differently than
a v; = treats the prefix as the number of
stack elements to evaluate at once, and N treats it as
a temporary different working precision.)
The evalvn function can take an alternate working
precision as an optional second argument. This argument can be
either an integer, to set the precision absolutely, or a vector
containing a single integer, to adjust the precision relative to
the current precision. Note that evalvn with a
larger than current precision will do the calculation at this
higher precision, but the result will as usual be rounded back
down to the current precision afterward. For example,
‘evalvn(pi -
3.1415)’ at a precision of 12 will return
‘9.265359e-5’;
‘evalvn(pi - 3.1415,
30)’ will return ‘9.26535897932e-5’ (computing a
25-digit result which is then rounded down to 12); and
‘evalvn(pi - 3.1415,
[-2])’ will return ‘9.2654e-5’.
The a "
(calc-expand-formula) command expands functions into
their defining formulas wherever possible. For example,
‘deg(x^2)’ is
changed to ‘180 x^2 /
pi’. Most functions, like sin
and gcd, are not defined by simple formulas and so
are unaffected by this command. One important class of functions
which can be expanded is the user-defined functions
created by the Z F command. See Algebraic
Definitions. Other functions which a " can expand
include the probability distribution functions, most of the
financial functions, and the hyperbolic and inverse hyperbolic
functions. A numeric prefix argument affects a " in
the same way as it does a v: A positive argument
expands all functions in the formula and then simplifies in
various ways; a negative argument expands and simplifies only the
top-level function call.
The a M
(calc-map-equation) [mapeq] command
applies a given function or operator to one or more equations. It
is analogous to V M, which operates on vectors instead
of equations. see Reducing and
Mapping. For example, a M S changes
‘x = y+1’ to
‘sin(x) =
sin(y+1)’, and a M + with
‘x = y+1’ and
‘6’ on the
stack produces ‘x+6 =
y+7’. With two equations on the stack, a
M + would add the lefthand sides together and the righthand
sides together to get the two respective sides of a new
equation.
Mapping also works on inequalities. Mapping two similar inequalities produces another inequality of the same type. Mapping an inequality with an equation produces an inequality of the same type. Mapping a ‘<=’ with a ‘<’ or ‘!=’ (not-equal) produces a ‘<’. If inequalities with opposite direction (e.g., ‘<’ and ‘>’) are mapped, the direction of the second inequality is reversed to match the first: Using a M + on ‘a < b’ and ‘a > 2’ reverses the latter to get ‘2 < a’, which then allows the combination ‘a + 2 < b + a’, which the a s command can then simplify to get ‘2 < b’.
Using a M *, a M /, a M n, or a M & to negate or invert an inequality will reverse the direction of the inequality. Other adjustments to inequalities are not done automatically; a M S will change ‘x < y’ to ‘sin(x) < sin(y)’ even though this is not true for all values of the variables.
With the
Hyperbolic flag, H a M [mapeqp] does a
plain mapping operation without reversing the direction of any
inequalities. Thus, H a M & would change x
> 2 to 1/x > 0.5. (This change is
mathematically incorrect, but perhaps you were fixing an
inequality which was already incorrect.)
With the Inverse
flag, I a M [mapeqr] always reverses the
direction of the inequality. You might use I a M C to
change ‘x <
y’ to ‘cos(x)
> cos(y)’ if you know you are working with
small positive angles.
The a b
(calc-substitute) [subst] command
substitutes all occurrences of some variable or sub-expression of
an expression with a new sub-expression. For example,
substituting ‘sin(x)’ with ‘cos(y)’ in ‘2 sin(x)^2 + x sin(x) + sin(2 x)’
produces ‘2 cos(y)^2 + x cos(y) +
sin(2 x)’. Note that this is
a purely structural substitution; the lone
‘x’ and the
‘sin(2 x)’
stayed the same because they did not look like
‘sin(x)’. See
Rewrite Rules, for
a more general method for doing substitutions.
The a b command normally prompts for two formulas, the old one and the new one. If you enter a blank line for the first prompt, all three arguments are taken from the stack (new, then old, then target expression). If you type an old formula but then enter a blank line for the new one, the new formula is taken from top-of-stack and the target from second-to-top. If you answer both prompts, the target is taken from top-of-stack as usual.
Note that a b has no understanding of commutativity
or associativity. The pattern ‘x+y’ will not match the formula
‘y+x’. Also,
‘y+z’ will not
match inside the formula ‘x+y+z’ because the
‘+’ operator
is left-associative, so the “deep structure” of that
formula is ‘(x+y) +
z’. Use d U
(calc-unformatted-language) mode to see the true
structure of a formula. The rewrite rule mechanism, discussed
later, does not have these limitations.
As an algebraic function, subst takes three
arguments: Target expression, old, new. Note that
subst is always evaluated immediately, even if its
arguments are variables, so if you wish to put a call to
subst onto the stack you must turn the default
simplifications off first (with m O).